package com.ruoyi.commodity.service.impl;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Collectors;

import com.ruoyi.common.annotation.DataScope;
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.core.domain.ProductCates;
import com.ruoyi.common.core.domain.TreeSelect;
import com.ruoyi.common.core.text.Convert;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.spring.SpringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.commodity.mapper.productCatesMapper;
import com.ruoyi.commodity.service.IproductCatesService;

/**
 * 分类管理Service业务层处理
 * 
 * @author ruoyi
 * @date 2023-09-06
 */
@Service
public class productCatesServiceImpl implements IproductCatesService 
{
    @Autowired
    private productCatesMapper productCatesMapper;

    /**
     * 查询分类管理
     * 
     * @param id 分类管理主键
     * @return 分类管理
     */
    @Override
    public ProductCates selectproductCatesById(Long id)
    {
        return productCatesMapper.selectproductCatesById(id);
    }

    /**
     * 查询分类管理列表
     * 
     * @param productCates 分类管理
     * @return 分类管理
     */
    @Override
    @DataScope(productCatesAlias = "pc")
    public List<ProductCates> selectproductCatesList(ProductCates productCates)
    {
        return productCatesMapper.selectproductCatesList(productCates);
    }

    @Override
    public int selectNormalChildrenById(Long id) {
        return productCatesMapper.selectNormalChildrenById(id);
    }

    /**
     * 新增分类管理
     * 
     * @param productCates 分类管理
     * @return 结果
     */
    @Override
    public int insertproductCates(ProductCates productCates)
    {
        ProductCates cates = productCatesMapper.selectproductCatesById(productCates.getParentId());
        if(!UserConstants.DEPT_NORMAL.equals(cates.getStatus())){
            throw new ServiceException("产品停用，不允许新增");
        }
        productCates.setAncestors(cates.getAncestors()+","+productCates.getParentId());
        productCates.setCreateTime(DateUtils.getNowDate());
        return productCatesMapper.insertproductCates(productCates);
    }

    /**
     * 修改子元素关系
     *
     * @param id 被修改的产品ID
     * @param ancestorsParentId 新的父ID集合
     * @param ancestorsId 旧的父ID集合
     */
    public void updateDeptChildren(Long id, String ancestorsParentId, String ancestorsId) {
        List<ProductCates> children = productCatesMapper.selectChildrenById(id);
        for (ProductCates child : children) {
            child.setAncestors(child.getAncestors().replaceFirst(ancestorsId, ancestorsParentId));
        }
        if (children.size() > 0) {
            productCatesMapper.updateCatesChildren(children);
        }
    }

    /**
     * 修改分类管理
     * 
     * @param productCates 分类管理
     * @return 结果
     */
    @Override
    public int updateproductCates(ProductCates productCates)
    {
        ProductCates selectParentId = productCatesMapper.selectproductCatesById(productCates.getParentId());
        ProductCates selectId = productCatesMapper.selectproductCatesById(productCates.getId());
        if(StringUtils.isNotNull(selectParentId) && StringUtils.isNotNull(selectId)){
            String ancestorsParentId = selectParentId.getAncestors()+ "," + selectParentId.getId();
            String ancestorsId = selectId.getAncestors();
            productCates.setAncestors(ancestorsParentId);
            updateDeptChildren(productCates.getId(),ancestorsParentId,ancestorsId);
        }
        productCates.setUpdateTime(DateUtils.getNowDate());
        int result = productCatesMapper.updateproductCates(productCates);
        if(UserConstants.DEPT_NORMAL.equals(productCates.getStatus()) && StringUtils.isNotEmpty(productCates.getAncestors()) && !StringUtils.equals("0",productCates.getAncestors())){
            updateParentDeptStatusNormal(productCates);
        }
        return result;
    }

    /**
     * 修改该产品的父级部门状态
     *
     * @param productCatest 当前产品
     */
    private void updateParentDeptStatusNormal(ProductCates productCatest)
    {
        String ancestors = productCatest.getAncestors();
        Long[] cates = Convert.toLongArray(ancestors);
        productCatesMapper.updateCatesStatusNormal(cates);
    }

    /**
     * 批量删除分类管理
     * 
     * @param ids 需要删除的分类管理主键
     * @return 结果
     */
    @Override
    public int deleteproductCatesByIds(Long[] ids)
    {
        return productCatesMapper.deleteproductCatesByIds(ids);
    }

    /**
     * 删除分类管理信息
     * 
     * @param id 分类管理主键
     * @return 结果
     */
    @Override
    public int deleteproductCatesById(Long id)
    {
        return productCatesMapper.deleteproductCatesById(id);
    }

    /**
     * 是否存在子节点
     * @param id
     * @return
     */
    @Override
    public boolean selectById(Long id) {
        int result = productCatesMapper.selectById(id);
        return result>0;
    }

    @Override
    public boolean selectSole(ProductCates productCates) {
        Long id = StringUtils.isNull(productCates.getId()) ? -1L : productCates.getId();
        ProductCates selectSole = productCatesMapper.selectSole(productCates.getName(), productCates.getParentId());
        if(StringUtils.isNotNull(selectSole) && selectSole.getId().longValue() != id.longValue()){
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    @Override
    public List<TreeSelect> selectProductTreeList(ProductCates productCates) {
        List<ProductCates> catesList = SpringUtils.getAopProxy(this).selectproductCatesList(productCates);
        return buildProductTreeSelect(catesList);
    }

    @Override
    public List<ProductCates> buildProductTree(List<ProductCates> productCatesList) {
        List<ProductCates> returnList = new ArrayList<>();
        List<Long> collect = productCatesList.stream().map(ProductCates::getId).collect(Collectors.toList());
        for (ProductCates product : productCatesList){
            //如果是顶节点，遍历该父节点下的所以子节的
            if(!collect.contains(product.getParentId())){
                recursionFn(productCatesList,product);
                returnList.add(product);
            }
        }
        if (returnList.isEmpty())
        {
            returnList = productCatesList;
        }
        return returnList;
    }

    @Override
    public List<TreeSelect> buildProductTreeSelect(List<ProductCates> productCatesList) {
        List<ProductCates> productTrees = buildProductTree(productCatesList);
        return productTrees.stream().map(TreeSelect::new).collect(Collectors.toList());
    }

    /**
     * 递归列表
     * @param productCatesList 子级
     * @param product 父级
     */
    private void recursionFn(List<ProductCates> productCatesList , ProductCates product){
        // 得到子节点列表
        List<ProductCates> childList = getChildList(productCatesList, product);
        product.setChildren(childList);
        for (ProductCates productCates : childList)
        {
            if (hasChild(productCatesList, productCates))
            {
                recursionFn(productCatesList, productCates);
            }
        }
    }

    /**
     * 获得子节点
     * @param productCatesList
     * @param product
     * @return
     */
    private List<ProductCates> getChildList(List<ProductCates> productCatesList, ProductCates product){
        List<ProductCates> returnList = new ArrayList<>();
        Iterator<ProductCates> iterator = productCatesList.iterator();
        while (iterator.hasNext()){
            ProductCates n = (ProductCates) iterator.next();
            if (StringUtils.isNotNull(n.getParentId()) && n.getParentId().longValue() == product.getId().longValue())
            {
                returnList.add(n);
            }
        }
        return returnList;
    }

    /**
     * 判断是否有子节点
     */
    private boolean hasChild(List<ProductCates> productCatesList, ProductCates product)
    {
        return getChildList(productCatesList, product).size() > 0;
    }
}
